<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
  <title></title>
    
</head>
  <body>
             <br>
                         
<table cellpadding="0" cellspacing="8" border="0" width="20%">
               <tbody>
                 <tr>
                   <td valign="middle" bgcolor="#ccccff"><small><a href="overview.html">
              BACK</a></small></td>
                   <td valign="middle" bgcolor="#ccccff"><small><a href="index.html">
              INDEX</a></small></td>
                   <td valign="middle" bgcolor="#ccccff"><small><a href="..">
      EXIT</a></small></td>
                   <td valign="middle" bgcolor="#ccccff"><small><a href="Server.html">
              NEXT</a></small></td>
                 </tr>
                                                   
  </tbody>             
</table>
             <br>
                         
<h1>The Jetty HTTP Server&nbsp;</h1>
          <big><b><a name="Introduction"></a><big>Introduction</big></b></big><br>
         <br>
         This section describes the important concepts in the Jetty HttpServer
   model.  &nbsp;It should be read by those with an interest in gaining a
deeper   insight  into the Jetty architecture and those considering writing
custom   handlers.<br>
        <br>
        The Introduction to the HttpServer explained that the server accepts
  requests   and passes them off to handlers for processing but did not elaborate
  on how  this is acheived. This section discusses the server, listener,
context   and  handler entities and the relationships between them.<br>
        <br>
        <br>
        <big><big><b><a name="HttpServer"></a>HttpServer</b></big></big><br>
          <br>
               The <a href="/javadoc/org/mortbay/http/HttpServer.html">org.mortbay.http.HttpServer</a>
              class provides a linkage between a collection of request listeners 
    and  collections of request handlers:               
<table align="center" width="90%" cellpadding="2" cellspacing="0" border="0">
   <tbody>
   <tr>
   <td><small><pre>
HttpListener&nbsp;<sup>n</sup>--&gt;<sup>1</sup>&nbsp;HttpServer&nbsp;<sup>1</sup>--&gt;<sup>n</sup>&nbsp;HttpContext&nbsp;<sup>1</sup>--&gt;<sup>n</sup>&nbsp;HttpHandler</pre>
</small>
               <b>Diagram: HttpServer&nbsp;relationship model </b><br>
   </td>
   </tr>
         
  </tbody>   
</table>
                 <br>
       It is the responsibility of an HttpServer to accept requests received
  by  an HttpListener, and match them to suitable HttpContext(s). It does
this  by using the host and <a href="/jetty/doc/PathMapping.html">context
path</a>    elements from the request. Note that more  than one HttpContext
might match  the request, and in this case, all HttpContexts  are tried <i>
 in the order  in which they were registered with the server</i>    until
the request is  marked as having been handled.<br>
               <br>
       The trivial code snippet from the Introduction to the HttpServer can 
 then   be represented as:                                             
                
<table align="center" width="90%" cellpadding="2" cellspacing="0" border="0">
   <tbody>
   <tr>
   <td><small><pre>
SocketListener<sup>1</sup>--&gt;<sup>1</sup>HttpServer<sup>1</sup>--&gt;<sup>1</sup>HttpContext<sup>1</sup>--&gt;<sup>1</sup>ResourceHandler
port:8080                        "/"             "./docroot"<br></pre>
   </small>                      
   <b>Diagram: Trivial file server object relationships</b><br>
   </td>
   </tr>
         
  </tbody>   
</table>
   <br>
        This depicts a single&nbsp;listener on port 8080 passing requests 
to  a  single server, which in turn passes them to a single context with a
single   handler which returns static content from the directory <tt>./docroot</tt>
      . <br>
                                                                        
                                    <br>
               <big><font size="+1"><big><b><a name="Listeners"></a>HttpListener</b></big></font></big><br>
          <br>
              Implementations of the <a href="/javadoc/org/mortbay/http/HttpListener.html">
             org.mortbay.http.HttpListener</a> interface are added to a HttpServer
     and  act as sources of requests for the server. The  <a href="/javadoc/org/mortbay/http/SocketListener.html">
             org.mortbay.http.SocketListener</a> is the main implementation.
  It  listens   on a standard TCP/IP port for requests, but there are also
 listener   implementations  for <a href="other.html">SSL</a>, <a href="other.html">
      Non blocking IO</a>, <a href="other.html">testing</a> and others. 
                                                                        
                                    
<p> Multiple listeners may be used to listen on different    ports and/or
 on specific   IP addresses.  This is most frequently used with  SSL or with
 multi-hosting:
                                                                     
      
<table align="center" width="90%" cellpadding="2" cellspacing="0" border="0">
   <tbody>
   <tr>
   <td><small><pre>
SocketListener -+
port:80         |
                |
JSSEListener   -+&gt; HttpServer --&gt; HttpContext --&gt; ResourceHandler
port:443        |                 "/"             "./docroot"
                |
SocketListener -+
host:1.2.3.4
port: 80           
</pre></small>
<b>Diagram: &nbsp;Multiple listeners with multihosting</b> </td>
   </tr>
  </tbody>   
</table>
<P>
Listeners are configured via <tt>set</tt> methods.  Listeners can
be  created    by  using the HttpServer as a factory to create a standard
 type  of listener:          <br>
                                                                        
                                                      
<table align="center" width="90%" cellpadding="2" cellspacing="0" border="0">
   <tbody>
   <tr>
   <td><pre><tt>
HttpServer server=new HttpServer();
HttpListener listener=
    server.addListener(new InetAddrPort("myhost",8080));
</pre></tt> 
<b>     Code Example: &nbsp;Convenience methods for adding standard
 listeners</b> </td>
   </tr>
         
  </tbody>   
</table>
   <br>
   <br>
              However, in order to provide detailed configuration, it is
more   common    to create  the listener directly and then add it to the
HttpServer:                                                             
                
<table align="center" width="90%" cellpadding="2" cellspacing="0" border="0">
   <tbody>
   <tr>
   <td> <tt><pre>
HttpServer server = new HttpServer();
SocketListener listener = new SocketListener();
listener.setHost("myhost");
listener.setPort(8080);<br>listener.setMinThreads(5);
listener.setMaxThreads(250);
server.addListener(listener);
</pre></tt>                
<b>Code Example: Configuring a listener</b> </td>
   </tr>
         
  </tbody>   
</table>
   <br>
   <br>
       All HttpListeners are responsible for allocating threads to requests,
     so most implementations are extensions of the  <a href="/javadoc/org/mortbay/util/ThreadedServer.html">
             org.mortbay.util.ThreadedServer</a> or <a href="/javadoc/org/mortbay/util/ThreadPool.html">
             org.mortbay.util.ThreadPool</a>. Thus attributes such as min/max 
  threads,     min/max idle times etc are also set via the API. 
<P>
Jetty has several type of HttpListeners including:<UL>
<LI><a href="/javadoc/org/mortbay/http/SocketListener.html">org.mortbay.http.SocketListener</a>
for normal http connections.
<LI><a href="/javadoc/org/mortbay/http/JsseListener.html">org.mortbay.http.JsseListener</a>
for SSL https connections using JSSE provider.
<LI><a href="/javadoc/org/mortbay/http/SunJsseListener.html">org.mortbay.http.SunJsseListener</a>
for SSL https connections using Suns JSSE provider.
<LI><a href="/javadoc/org/mortbay/http/SocketChannelListener.html">org.mortbay.http.SocketChannelListener</a>
for normal http connections using the java.nio library for non-blocking idle connections.
<LI><a href="/javadoc/org/mortbay/http/ajp/AJP13Listener.html">org.mortbay.http.ajp.AJP13Listener</a>
for integration with apache, IIS etc. See <a href="../doc/JettyWithApache.html">FAQ</a>.
</UL>                                             
                     

<p>&nbsp;
                                                                                                       
                                           
<p> <font size="+1"><b><a name="Contexts"></a><big>      HttpContext</big></b></font></p>
                                                                        
                                                                        
                                                                   
<p>        A <a href="/javadoc/org/mortbay/http/HttpContext.html">     org.mortbay.http.HttpContext</a>
   aggregates  <a href="/javadoc/org/mortbay/http/HttpHandler.html">    
      org.mortbay.http.HttpHandler</a> implementations. When a request  is
  passsed to a HttpContext it tries each of its HttpHandlers in turn (<i>
   in  the order in which they were registered</i>) until the request is
marked   as handled. Note that it is perfectly possible for more than one
handler  to process the request, but only one handler can mark the request
as being  finally handled.  </p>
                                            
<table border=1><tr><td><i>  
Note that in Jetty 3.1 and previous releases, the HttpContext class was called HandlerContext.<br>
</i></td></tr></table>                                                                                                  
                            
<p>A typical a context might have handlers for security,  servlets  and static
 resources:                                                                                                                 
       
<table align="center" width="90%" cellpadding="2" cellspacing="0" border="0">
   <tbody>
   <tr>
   <td><small><tt><pre>
                                              +-&gt; SecurityHandler
                                              |
SocketListener --&gt; HttpServer --&gt; HttpContext +-&gt; ServletHandler
port: 80                          "/"         |
                                              +-&gt; ResourceHandler
</pre></tt></small>
   <b> Diagram: Single context, multiple handlers </b> </td>
      </tr>
       
  </tbody>   
</table>
                                                       <br>
       All HttpHandlers within a single HttpContext share the following attributes:
                                                                        
                     
<ul>
              <li>Initialization parameters </li>
               <li>An optional virtual host name for the context </li>
               <li>A path prefix for the context </li>
               <li>A resource base for loading static resources (files/urls) </li>
               <li>A memory cache of resources (files/urls) </li>
               <li>A ClassLoader and set of Java permissions </li>
               <li>A request log </li>
               <li>Statistics </li>
               <li>Error page mappings </li>
               <li>MIME type suffix maps  </li>
</ul>
                                                                        
                                            <br>
       A single HttpServer can have multiple HttpContexts. &nbsp;This is
typically    used to serve several applications  from  the same port(s) using
URL mappings:<br>
                                                                        
     
<table align="center" width="90%" cellpadding="2" cellspacing="0" border="0">
   <tbody>
   <tr>
   <td><small><tt><pre>
SocketListener --&gt; HttpServer +-&gt; HttpContext --&gt; HttpHandler(s)
port:80                       |   path:"/alpha/*"
                              |
                              +-&gt; HttpContext --&gt; HttpHandler(s)
                                  path:"/beta/*"
</pre></tt></small>
       <b>Diagram: &nbsp;Multiple contexts with URL mapping</b> </td>
   </tr>
         
  </tbody>   
</table>
   <br>
       Alternatively,&nbsp; different applications can be served from the 
same   port using virtual hosts:                                         
         
<table align="center" width="90%" cellpadding="2" cellspacing="0" border="0">
   <tbody>
   <tr>
   <td><small><tt><pre>
SocketListener --&gt; HttpServer +-&gt; HttpContext --&gt; HttpHandler(s)
port:80                       |   vhost: www.alpha.com
                              |   path: "/"
                              |
                              +-&gt; HttpContext --&gt; HttpHandler(s)
                                  vhost: www.beta.com
                                  path: "/"
</pre></tt></small>
       <b>Diagram:  Multiple contexts with virtual hosts</b> </td>
   </tr>
         
  </tbody>   
</table>
                                                                        
                    <br>
       If multiple contexts are to be served from the same port, but on different 
       IP addresses, then it is possible to give each context its own HttpServer: 
                                          <br>
      
<table align="center" width="90%" cellpadding="2" cellspacing="0" border="0">
   <tbody>
   <tr>
   <td><small><tt><pre>
SocketListener --&gt; HttpServer --&gt; HttpContext --&gt; HttpHandler(s)
host:www.alpha.com                path:"/"
port:80

SocketListener --&gt; HttpServer --&gt; HttpContext --&gt; HttpHandler(s)
host:www.beta.com                 path: "/"
port:80
</pre></tt></small>                                                                
                                  <b> Diagram: &nbsp;Multiple servers</b>
       </td>
   </tr>
         
  </tbody>   
</table>
   <br>
   <br>

HttpContexts can be instantiated  by the HttpServer as part of a
 call to <code>addContext()</code> with context args:<br>
                                                                        
<table align="center" width="90%" cellpadding="2" cellspacing="0" border="0">
   <tbody>
   <tr>
   <td><small><pre>
HttpContext context = server.addContext("/mydocs/*");
context.setResourceBase("./docroot/");
</pre></small>
<b> Code Example: &nbsp;Implied context creation</b>  </td>
   </tr>
         
  </tbody>   
</table>
   <br>
    <br>
        As addContext() will always create a new context instance, it is
possible    to accidentally create multiple copies of the same context (by
calling addContext()   with the same parameters). To avoid this, you can
use the                                                                 
                                     <tt> getContext()                  
                                                                        
             </tt> method instead, which will only create  a new context
if one with the same specification does not already exist:<br>
                                                                        
     
<table align="center" width="90%" cellpadding="2" cellspacing="0" border="0">
   <tbody>
   <tr>
   <td><small><pre>
HttpContext context = server.getContext("myhost","/mydocs/*");
context.setResourceBase("./docroot/");
</pre></small>                                                                
   <b> Code Example: &nbsp;Lazy context creation</b> </td>
   </tr>
         
  </tbody>   
</table>
   <br>
   <br>
The previous example highlights that it is possible specify a virtual
 host  as well as the context path. A single context may be registered with
 different  virtual hosts.  Once context configuration becomes complex, it
is best to take explicit control over context creation:<br>
                                                                        
     
<table align="center" width="90%" cellpadding="2" cellspacing="0" border="0">
   <tbody>
   <tr><td><small><pre>
HttpContext context = new HttpContext();
context.setContextPath("/context/*");
context.setVirtualHosts(new String[]{"alpa.com","beta.com"});
context.setResourceBase("./docroot/");
server.addContext(context);
</pre></small> 
<b> Code Example: &nbsp;Creating a context with multiple
virtual  hosts</b> </td>
   </tr>
         
  </tbody>   
</table>
                                                            <br>
                                                                      
<table border=1><tr><td><i>  
                                                            <b> Developers 
  Note:</b>  &nbsp;Derivations of HttpServer may implement the       
                                                                        
                                              <code> newHttpContext()</code>
            method to change the factory method for creating new contexts.
  This   is  used, for example, by the <a href="/javadoc/org/mortbay/jetty/Server.html">
      org.mortbay.jetty.Server</a>        class to return  HttpContext derivations 
  that have convenience methods   for configuring servlets. The <a href="/javadoc/org/mortbay/jetty/server/WebApplicationContext.html">
             org.mortbay.jetty.servlet.WebApplicationContext</a> class is 
a  specialization      of HttpContext that configures the handlers by looking 
 at the standard   web   application XML files.<br>
</i></td></tr></table>
                                                                        
                                                            <br>
                                                                        
                                                            <br>
                                                                        
                                                                        
                                                                        
                                                                        
                                                                        
                                                                        
                                                                        
                                                                        
                                                                        
                          
<p>       <font size="+1"><b><a name="Handlers"></a><big> HttpHandler</big></b></font></p>
                                                                        
                                                                        
                                                                        
                                                                        
                                                                        
                                                                        
                                                                      
                                                                        
                                                          
<p>            The <a href="/javadoc/org/mortbay/http/HttpHandler.html">org.mortbay.http.HttpHandler</a>
              interface represents Jetty's core unit of content generation
 or  manipulation.     Implementations of this interface can be used to modify 
  or handle requests.     Typically, handlers are arranged in a list, and 
a  request presented to  each    handler in turn until (at most) one indicates 
  that the request has  been handled.     This allows handlers to: </p>
                                                                        
                                                                        
                                                                        
                                                                        
                                                                        
                                                                        
                                                                        
                                                                        
                                                                        
                              
<ul>
                                                                        
                                                              <li> Ignore 
requests   that are not applicable</li>
                                                                        
                                                              <li> Handle 
requests   by populating the response and/or generating content      </li>
                                                                        
                                                              <li> Modify 
the   request but allow it to pass onto the next handler(s).    Headers and 
attributes   may be modified or an InputStream filter added   </li>
                                                                        
                                                              <li> Modify 
the   response but allow the request to pass onto the next  handler(s).  
Headers   may be modified or OutputStream filters added. </li>
                                                                        
                                                                        
                                                                        
                                                                        
                                                                        
                                                                        
                                                                        
                                                                        
                                                          
</ul>
              The handlers provided with the <a href="/javadoc/org/mortbay/http/handler/package-summary.html">
             org.mortbay.http.handler</a> package are:                  
       
<table border="0" width="90%" cellpadding="2" cellspacing="10">
   <tbody>
   <tr>
   <td align="left" valign="top"><a href="/javadoc/org/mortbay/http/handler/ResourceHandler.html">
       ResourceHandler</a></td>
   <td align="left" valign="top">      Serve static content from the resource
 base of the HttpContext (see   below).</td>
                                                                        
   </tr>
   <tr>
   <td align="left" valign="top"><a href="/javadoc/org/mortbay/http/handler/SecurityHandler.html">
       SecurityHandler</a></td>
   <td align="left" valign="top">      Provide BASIC and FORM authentication.</td>
   </tr>
   <tr>
   <td align="left" valign="top"><a href="/javadoc/org/mortbay/http/handler/ContentEncodingHandler.html">
       ContentEncodingHandler</a></td>
   <td align="left" valign="top">      Provides content encoding such as gzip and compress for requests and response content.
    More efficient than the servlet filter implementation.</td>
   </tr>
   <tr>
   <td align="left" valign="top"><a href="/javadoc/org/mortbay/http/handler/HTAccessHandler.html">
       HTAccessHandler</a></td>
   <td align="left" valign="top">      Provide apache .htaccess style security.</td>
   </tr>
   <tr>
   <td align="left" valign="top"><a href="/javadoc/org/mortbay/http/handler/NotFoundHandler.html">
       NotFoundHandler</a></td>
                                                                        
   <td align="left" valign="top">      Handles unserviced requests.</td>
   </tr>
   <tr>
   <td align="left" valign="top"><a href="/javadoc/org/mortbay/http/handler/DumpHandler.html">
       DumpHandler</a></td>
   <td align="left" valign="top">      A debugging tool that dumps the request
 and response headers.</td>
   </tr>
   <tr>
   <td align="left" valign="top"><a href="/javadoc/org/mortbay/http/handler/ForwardHandler.html">
       ForwardHandler</a></td>
   <td align="left" valign="top">      Forward a request to another URL</td>
   </tr>
   <tr>
   <td align="left" valign="top"><a href="/javadoc/org/mortbay/http/handler/NullHandler.html">
       NullHandler</a></td>
   <td align="left" valign="top">      An abstract base implementation of 
the interface, used for to derive other handlers.</td>
   </tr>
         
  </tbody>   
</table>
                                                                        
                                                                        
 A <a href="/javadoc/org/mortbay/jetty/servlet/ServletHandler.html">ServletHandler</a>
  and
<a href="/javadoc/org/mortbay/jetty/servlet/WebApplicationHandler.html">WebApplicationHandler</a>

  are provided by the <a href="/javadoc/org/mortbay/jetty/servlet/package-summary.html">
             org.mortbay.jetty.servlet</a> package and is discussed in detail 
  in  the <a href="Server.html">Jetty Server</a> section.<br>
                                                                        
                                                                   
                                                                      
                                                                        
                                                                        
                                                                  
<p>      HttpHandlers are tried within a context in the order they were added
  to  the HttpContext. The following code creates a  context that checks
authentication,      then tries a servlet mapping before trying static content
then finally  dropping through to an error page generator if no handler marks
the request  as handled:</p>
                                                                        
      
<table align="center" width="90%" cellpadding="2" cellspacing="0" border="0">
   <tbody>
   <tr>
   <td>      <tt>               
      <pre>HttpContext context = server.addContext("/");<br>context.add(new SecurityHandler());<br>context.add(new ServletHandler());<br>context.add(new ResourceHandler());<br>context.add(new NotFoundHandler());<br></pre>
   </tt>                                                                
                                        <b>Code Example: &nbsp;Importance 
of handler ordering</b> </td>
   </tr>
         
  </tbody>   
</table>
                                                                        
   <br>
   <br>
                                                                        
     <font size="+1"><b><br>
   Resource Handler</b></font><br>                                    
                                                                  
<p>    One of the most common things for a HttpServer to do is to serve static 
  content  from a base  directory or URL. The <a href="/javadoc/org/mortbay/http/handler/ResourceHandler.html">
          org.mortbay.http.handler.ResourceHandler</a>    implementation
of  HttpHandler    is provided for this purpose.   Its features   include:</p>
                                                                        
                                                                    
                                     
<ul>
              <li>Support for GET, PUT, MOVE, DELETE, HEAD and OPTIONS methods. 
                                                                         
                                                                        
                                                                        
                                                                       </li>
               <li>Handling of IfModified headers. </li>
               <li>HTTP/1.1 Range support for partial content serving. </li>
               <li>Index/welcome files. </li>
               <li>Generation of directory listings. </li>
                                                                        
                                                                        
</ul>
                                                                        
                                                                        
  <br>
      The root directory or URL for serving static content is the ResourceBase 
     of the HttpContext.  Thus, to  serve static content from the directory 
                                                                         
                                                                      <tt>
      "./docroot/"</tt>:<br>
                   
<table align="center" width="90%" cellpadding="2" cellspacing="0" border="0">
   <tbody>
   <tr>
   <td><small><pre>
HttpContext context = server.getContext("/context/*");
context.setResourceBase("./docroot/");
ResourceHandler handler = new ResourceHandler();
handler.setDirAllowed(true);
handler.setPutAllowed(false);
handler.setDelAllowed(false);
handler.setAcceptRanges(true);
context.addHandler(handler);
context.addHandler(new NotFoundHandler());
</pre>
   </small>                                                                
                                                                        
    <b> Code Example: &nbsp;Detailed configuration of a  ResourceHandler</b>
    </td>
   </tr>
         
  </tbody>   
</table>
<br>
The <tt>NotFoundHandler</tt> is added to generate a 404 for requests for
resources that don't exist.  The <tt>ResourceHandler</tt> lets requests that
it cannot handle fall through to the next handler.
<P>                                           
<table border=1><tr><td><i>  
<b> Developers  Note:</b><br>
HttpHandlers ARE ORDER DEPENDANT!.   If in the above example the <tt>NotFoundHandler</tt>
had been added to the context before the <tt>ResourceHandler</tt>, then all
requests would be 404'd and resources would not be served.   It is a common
mistake to put a <tt>ResourceHandler</tt> before a 
<tt>ServletHandler</tt> with the JSPServlet, so jsp source code is served
rather than the dynamic content from the JSPServlet.
</i></td></tr></table>



    <br>
   <br>
   <big><big><b><a name="together"></a>Putting It All Together</b></big></big>
     
<p> Finally, here is a fully worked code example to configure a server on
 port <tt>8181</tt> serving static content and a dump servlet at <tt>"/mystuff/"</tt>
  :  
<table align="center" width="90%" cellpadding="2" cellspacing="0" border="0">
   <tbody>
   <tr>
   <td><small><pre>   
import java.io.*;
import java.net.*;
import org.mortbay.util.*;
import org.mortbay.http.*;
import org.mortbay.jetty.servlet.*;
import org.mortbay.http.handler.*;
import org.mortbay.servlet.*;     
      
public class SimpleServer
{
  public static void main (String[] args)
    throws Exception
  {
    // Create the server
    HttpServer server=new HttpServer();
      
    // Create a port listener
    SocketListener listener=new SocketListener();
    listener.setPort(8181);
    server.addListener(listener);

    // Create a context 
    HttpContext context = new HttpContext();
    context.setContextPath("/mystuff/*");
    server.addContext(context);
      
    // Create a servlet container
    ServletHandler servlets = new ServletHandler();
    context.addHandler(servlets);

    // Map a servlet onto the container
    servlets.addServlet("Dump","/Dump/*","org.mortbay.servlet.Dump");
      
    // Serve static content from the context
    String home = System.getProperty("jetty.home",".");
    context.setResourceBase(home+"/demo/webapps/jetty/tut/");
    context.addHandler(new ResourceHandler());

    // Start the http server
    server.start ();
  }
}
</pre></small>       
</td>
</tr>
<tr>
<td>
<b><br>
 Code Example:  Setting up an HttpServer </b></td>
   </tr>
         
  </tbody>   
</table>
    </p>
                                                                        
                                                                        
                                                                        
                                                                        
                                                                    
<table cellpadding="0" cellspacing="8" border="0" width="20%">
              <tbody>
                 <tr>
                   <td valign="middle" bgcolor="#ccccff"><small><a href="overview.html">
              BACK</a></small></td>
                   <td valign="middle" bgcolor="#ccccff"><small><a href="index.html">
              INDEX</a></small></td>
                   <td valign="middle" bgcolor="#ccccff"><small><a href="..">
      EXIT</a></small></td>
                   <td valign="middle" bgcolor="#ccccff"><small><a href="Server.html">
              NEXT</a></small></td>
                 </tr>
                                                                        
                             
  </tbody>    
</table>
                                                                        
                                                                        
                                                                        
                                                                        
                                                                        
                                                            
</body>
</html>
